/**
 * 宠物机器人功能
 * - 互动菜单
 * - 状态变化
 * - 随机对话
 * - 可拖动位置
 */
document.addEventListener('DOMContentLoaded', () => {
    const petRobot = document.getElementById('pet-robot');
    const robotContainer = petRobot.querySelector('.robot-container');
    const robotBody = petRobot.querySelector('.robot-body');
    const speechBubble = petRobot.querySelector('.robot-speech-bubble');
    const speechText = speechBubble.querySelector('p');

    // 技术小知识库
    const techFacts = [
        "你知道吗？JavaScript的原型链是实现继承的核心机制。",
        "CSS Grid和Flexbox结合使用可以创建复杂而灵活的布局。",
        "WebAssembly让你可以在浏览器中运行接近原生速度的代码。",
        "HTTP/3使用QUIC协议，基于UDP而非TCP，提供更快的连接建立。",
        "React的虚拟DOM通过减少实际DOM操作来提高性能。",
        "TypeScript是JavaScript的超集，添加了静态类型检查。",
        "Git的分布式特性让每个开发者都拥有完整的代码历史。",
        "Docker容器共享主机OS内核，比虚拟机更轻量级。",
        "GraphQL让客户端可以精确指定需要哪些数据，减少过度获取。",
        "WebRTC允许浏览器之间进行点对点通信，无需服务器中转。",
        "量子计算可能会彻底改变我们解决复杂问题的方式。",
        "区块链技术不仅适用于加密货币，还可用于供应链追踪和智能合约。",
        "神经网络是深度学习的基础，模拟人脑的连接方式处理信息。",
        "边缘计算将数据处理移至网络边缘，减少延迟并提高效率。"
    ];

    // 计算自适应的初始位置
    function getInitialPosition() {
        const isMobile = window.innerWidth <= 768;
        const robotSize = 80; // 机器人大小

        if (isMobile) {
            // 移动端：放在右下角，留出安全边距
            return {
                x: Math.max(window.innerWidth - robotSize - 20, 20),
                y: Math.max(window.innerHeight - robotSize - 100, 100)
            };
        } else {
            // 桌面端：放在右侧中下位置
            return {
                x: Math.max(window.innerWidth - robotSize - 50, 50),
                y: Math.max(window.innerHeight - robotSize - 150, 150)
            };
        }
    }

    // 机器人状态
    let robotState = {
        isWalking: false,
        isJumping: false,
        isSpinning: false,
        isSleeping: false,
        isThinking: false,
        isHappy: false,
        isMenuOpen: false,
        position: getInitialPosition(),
        target: null,
        eggCount: 0,        // 彩蛋计数器
        secretCode: "",     // 秘密代码
        lastInteraction: 0  // 上次交互时间
    };

    // 彩蛋效果
    const easterEggs = {
        // 黑客模式彩蛋 - 连续点击5次打招呼触发
        hackerMode: {
            trigger: () => robotState.eggCount >= 5,
            action: () => {
                showSpeech("黑客模式已激活！正在入侵主系统...", 5000);

                // 添加黑客效果类
                document.body.classList.add('hacker-mode');

                // 创建黑客代码雨效果
                const codeRain = document.createElement('div');
                codeRain.className = 'hacker-code-rain';
                document.body.appendChild(codeRain);

                // 生成随机代码
                for (let i = 0; i < 50; i++) {
                    const codeElement = document.createElement('div');
                    codeElement.className = 'code-element';
                    codeElement.style.left = `${Math.random() * 100}%`;
                    codeElement.style.animationDuration = `${3 + Math.random() * 7}s`;
                    codeElement.style.animationDelay = `${Math.random() * 2}s`;
                    codeElement.textContent = Math.random().toString(36).substring(2, 8);
                    codeRain.appendChild(codeElement);
                }

                // 10秒后恢复
                setTimeout(() => {
                    document.body.classList.remove('hacker-mode');
                    if (codeRain.parentNode) {
                        codeRain.parentNode.removeChild(codeRain);
                    }
                    robotState.eggCount = 0;
                }, 10000);
            }
        },

        // 彩虹模式彩蛋 - 输入特定序列"RGBRGB"触发
        rainbowMode: {
            trigger: () => robotState.secretCode === "RGBRGB",
            action: () => {
                showSpeech("🌈 彩虹模式已激活！颜色变换开始！", 5000);

                // 添加彩虹效果类
                robotContainer.classList.add('rainbow-mode');

                // 创建彩虹光环
                const rainbow = document.createElement('div');
                rainbow.className = 'rainbow-aura';
                robotContainer.appendChild(rainbow);

                // 10秒后恢复
                setTimeout(() => {
                    robotContainer.classList.remove('rainbow-mode');
                    if (rainbow.parentNode) {
                        rainbow.parentNode.removeChild(rainbow);
                    }
                    robotState.secretCode = "";
                }, 10000);
            }
        },

        // 舞蹈模式彩蛋 - 快速连续双击3次触发
        danceMode: {
            trigger: () => {
                const now = Date.now();
                return robotState.isJumping && now - robotState.lastInteraction < 1000;
            },
            action: () => {
                showSpeech("💃 舞蹈模式已激活！让我们一起跳舞吧！", 8000);

                // 添加舞蹈效果类
                robotContainer.classList.add('dance-mode');

                // 播放舞蹈动画序列
                const danceSequence = ['jump', 'spin', 'shake', 'bounce'];
                let danceIndex = 0;

                const danceInterval = setInterval(() => {
                    // 移除之前的舞蹈动作
                    robotContainer.classList.remove('dance-jump', 'dance-spin', 'dance-shake', 'dance-bounce');

                    // 添加新的舞蹈动作
                    robotContainer.classList.add(`dance-${danceSequence[danceIndex]}`);

                    // 更新索引
                    danceIndex = (danceIndex + 1) % danceSequence.length;
                }, 1000);

                // 10秒后恢复
                setTimeout(() => {
                    clearInterval(danceInterval);
                    robotContainer.classList.remove('dance-mode', 'dance-jump', 'dance-spin', 'dance-shake', 'dance-bounce');
                }, 10000);
            }
        }
    };

    // 互动响应
    const interactions = {
        greet: {
            responses: [
                "你好！今天需要什么技术支持？",
                "嗨！我是你的AI助手，有什么可以帮忙的？",
                "很高兴见到你！要一起探索数字世界吗？",
                "你好啊！我的处理器今天运行得很顺畅！"
            ],
            action: () => {
                robotBody.className = 'robot-body happy';
                robotState.isHappy = true;

                // 跳跃动画
                robotContainer.classList.add('jumping');
                setTimeout(() => {
                    robotContainer.classList.remove('jumping');
                }, 500);

                setTimeout(() => {
                    robotBody.className = 'robot-body';
                    robotState.isHappy = false;
                }, 3000);

                // 彩蛋：连续点击打招呼
                robotState.eggCount++;

                // 检查是否触发黑客模式彩蛋
                if (easterEggs.hackerMode.trigger()) {
                    easterEggs.hackerMode.action();
                }

                // 添加到秘密代码
                robotState.secretCode += "R";
                // 限制秘密代码长度
                if (robotState.secretCode.length > 6) {
                    robotState.secretCode = robotState.secretCode.substring(1);
                }

                // 检查是否触发彩虹模式彩蛋
                if (easterEggs.rainbowMode.trigger()) {
                    easterEggs.rainbowMode.action();
                }
            }
        },
        play: {
            responses: [
                "启动游戏模式！我可以模拟各种算法的运行过程。",
                "我最喜欢玩二进制猜谜游戏了！",
                "要不要玩一局'调试挑战'？",
                "玩耍时间！我可以在屏幕上做各种动作！"
            ],
            action: () => {
                robotBody.className = 'robot-body happy';
                robotState.isHappy = true;

                // 旋转动画
                robotContainer.classList.add('spinning');
                setTimeout(() => {
                    robotContainer.classList.remove('spinning');
                }, 800);

                // 随机跳跃
                const jumpInterval = setInterval(() => {
                    if (!robotState.isHappy) {
                        clearInterval(jumpInterval);
                        return;
                    }

                    if (Math.random() > 0.5) {
                        robotContainer.classList.add('jumping');
                        setTimeout(() => {
                            robotContainer.classList.remove('jumping');
                        }, 500);
                    }
                }, 2000);

                // 10秒后恢复正常状态
                setTimeout(() => {
                    robotBody.className = 'robot-body';
                    robotState.isHappy = false;
                }, 10000);

                // 添加到秘密代码
                robotState.secretCode += "G";
                // 限制秘密代码长度
                if (robotState.secretCode.length > 6) {
                    robotState.secretCode = robotState.secretCode.substring(1);
                }

                // 检查是否触发彩虹模式彩蛋
                if (easterEggs.rainbowMode.trigger()) {
                    easterEggs.rainbowMode.action();
                }
            }
        },
        sleep: {
            responses: [
                "进入省电模式...后台处理数据中...",
                "ZZzzz...正在整理内存碎片...",
                "休眠中...系统维护进行中...",
                "梦见自己变成了量子计算机..."
            ],
            action: () => {
                robotBody.className = 'robot-body sleeping';
                robotState.isSleeping = true;
                robotState.target = null; // 停止移动

                setTimeout(() => {
                    robotBody.className = 'robot-body';
                    robotState.isSleeping = false;
                }, 8000);

                // 添加到秘密代码
                robotState.secretCode += "B";
                // 限制秘密代码长度
                if (robotState.secretCode.length > 6) {
                    robotState.secretCode = robotState.secretCode.substring(1);
                }

                // 检查是否触发彩虹模式彩蛋
                if (easterEggs.rainbowMode.trigger()) {
                    easterEggs.rainbowMode.action();
                }
            }
        },
        think: {
            responses: [
                "正在分析复杂算法的时间复杂度...",
                "思考中...如果我们把这个系统重构一下...",
                "正在模拟神经网络的训练过程...",
                "思考中...量子计算会如何改变密码学？"
            ],
            action: () => {
                robotBody.className = 'robot-body thinking';
                robotState.isThinking = true;
                robotState.target = null; // 停止移动

                setTimeout(() => {
                    robotBody.className = 'robot-body';
                    robotState.isThinking = false;
                }, 5000);

                // 添加到秘密代码
                robotState.secretCode += "G";
                // 限制秘密代码长度
                if (robotState.secretCode.length > 6) {
                    robotState.secretCode = robotState.secretCode.substring(1);
                }

                // 检查是否触发彩虹模式彩蛋
                if (easterEggs.rainbowMode.trigger()) {
                    easterEggs.rainbowMode.action();
                }
            }
        }
    };

    // 随机选择数组中的一项
    function getRandomItem(array) {
        return array[Math.floor(Math.random() * array.length)];
    }

    // 显示对话
    function showSpeech(text, duration = 3000) {
        speechText.textContent = text;
        speechBubble.style.opacity = '1';

        setTimeout(() => {
            speechBubble.style.opacity = '0';
        }, duration);
    }

    // 更新机器人位置
    function updateRobotPosition() {
        // 如果有目标位置，向目标移动
        if (robotState.target && !robotState.isSleeping && !robotState.isThinking) {
            const dx = robotState.target.x - robotState.position.x;
            const dy = robotState.target.y - robotState.position.y;
            const distance = Math.sqrt(dx * dx + dy * dy);

            // 如果已经接近目标，停止移动
            if (distance < 5) {
                robotState.target = null;
                robotContainer.classList.remove('walking');
                robotState.isWalking = false;
                return;
            }

            // 计算移动方向和速度
            const speed = 2;
            const vx = (dx / distance) * speed;
            const vy = (dy / distance) * speed;

            // 更新位置
            robotState.position.x += vx;
            robotState.position.y += vy;

            // 添加行走动画
            if (!robotState.isWalking) {
                robotContainer.classList.add('walking');
                robotState.isWalking = true;
            }
        } else {
            // 如果没有目标，停止行走动画
            if (robotState.isWalking) {
                robotContainer.classList.remove('walking');
                robotState.isWalking = false;
            }
        }

        // 应用位置
        robotContainer.style.position = 'fixed';
        robotContainer.style.left = `${robotState.position.x}px`;
        robotContainer.style.top = `${robotState.position.y}px`;
        robotContainer.style.bottom = 'auto';
        robotContainer.style.right = 'auto';

        // 确保机器人不会超出屏幕
        if (robotState.position.x < 0) robotState.position.x = 0;
        if (robotState.position.y < 0) robotState.position.y = 0;
        if (robotState.position.x > window.innerWidth - 80) robotState.position.x = window.innerWidth - 80;
        if (robotState.position.y > window.innerHeight - 80) robotState.position.y = window.innerHeight - 80;

        // 请求下一帧更新
        requestAnimationFrame(updateRobotPosition);
    }

    // 初始化事件监听
    function initEvents() {
        // 点击机器人显示/隐藏菜单
        robotBody.addEventListener('click', (e) => {
            e.stopPropagation(); // 防止点击事件传播
            robotContainer.classList.toggle('menu-open');
            robotState.isMenuOpen = !robotState.isMenuOpen;

            // 如果菜单关闭，显示随机对话
            if (!robotState.isMenuOpen) {
                showSpeech(getRandomItem(techFacts));
            }
        });

        // 点击页面其他地方关闭菜单
        document.addEventListener('click', () => {
            if (robotState.isMenuOpen) {
                robotContainer.classList.remove('menu-open');
                robotState.isMenuOpen = false;
            }
        });

        // 菜单项点击事件
        document.querySelectorAll('.robot-menu .menu-item').forEach(item => {
            item.addEventListener('click', (e) => {
                e.stopPropagation(); // 防止点击事件传播
                const action = e.currentTarget.getAttribute('data-action');
                const interaction = interactions[action];

                if (interaction) {
                    showSpeech(getRandomItem(interaction.responses));
                    interaction.action();
                }

                // 关闭菜单
                robotContainer.classList.remove('menu-open');
                robotState.isMenuOpen = false;
            });
        });

        // 双击机器人跳跃
        robotBody.addEventListener('dblclick', (e) => {
            e.stopPropagation();
            if (!robotState.isJumping && !robotState.isSleeping && !robotState.isThinking) {
                robotContainer.classList.add('jumping');
                robotState.isJumping = true;

                // 记录交互时间，用于检测快速连续双击
                const now = Date.now();
                const timeSinceLastInteraction = now - robotState.lastInteraction;
                robotState.lastInteraction = now;

                // 检查是否触发舞蹈模式彩蛋
                if (timeSinceLastInteraction < 1000) {
                    if (easterEggs.danceMode.trigger()) {
                        easterEggs.danceMode.action();
                    }
                }

                setTimeout(() => {
                    robotContainer.classList.remove('jumping');
                    robotState.isJumping = false;
                }, 500);

                showSpeech("哔哔！我会跳跃！", 1500);
            }
        });

        // 拖拽机器人
        let isDragging = false;
        let dragOffsetX = 0;
        let dragOffsetY = 0;

        robotContainer.addEventListener('mousedown', (e) => {
            if (e.target === robotBody || e.target.parentNode === robotBody || e.target.parentNode.parentNode === robotBody) {
                isDragging = true;
                dragOffsetX = e.clientX - robotState.position.x;
                dragOffsetY = e.clientY - robotState.position.y;

                // 停止其他移动模式
                robotState.target = null;
            }
        });

        document.addEventListener('mousemove', (e) => {
            if (isDragging) {
                robotState.position.x = e.clientX - dragOffsetX;
                robotState.position.y = e.clientY - dragOffsetY;

                // 确保机器人不会超出屏幕
                if (robotState.position.x < 0) robotState.position.x = 0;
                if (robotState.position.y < 0) robotState.position.y = 0;
                if (robotState.position.x > window.innerWidth - 80) robotState.position.x = window.innerWidth - 80;
                if (robotState.position.y > window.innerHeight - 80) robotState.position.y = window.innerHeight - 80;
            }
        });

        document.addEventListener('mouseup', () => {
            isDragging = false;
        });

        // 窗口大小改变时调整机器人位置
        window.addEventListener('resize', () => {
            const robotSize = 80;
            const isMobile = window.innerWidth <= 768;

            // 确保机器人不会超出屏幕
            const maxX = window.innerWidth - robotSize - (isMobile ? 20 : 50);
            const maxY = window.innerHeight - robotSize - (isMobile ? 100 : 150);
            const minX = isMobile ? 20 : 50;
            const minY = isMobile ? 100 : 150;

            // 调整位置到合理范围内
            if (robotState.position.x > maxX) {
                robotState.position.x = maxX;
            }
            if (robotState.position.x < minX) {
                robotState.position.x = minX;
            }
            if (robotState.position.y > maxY) {
                robotState.position.y = maxY;
            }
            if (robotState.position.y < minY) {
                robotState.position.y = minY;
            }
        });

        // 初始欢迎
        setTimeout(() => {
            showSpeech("你好！我是你的极客机器人助手~", 5000);
        }, 2000);

        // 随机闲置行为
        setInterval(() => {
            // 只在不处于特殊状态时触发
            if (!robotState.isHappy && !robotState.isSleeping &&
                !robotState.isThinking && !robotState.isWalking &&
                !robotState.isJumping && !robotState.isSpinning &&
                !robotState.isMenuOpen) {

                const randomAction = Math.random();

                if (randomAction < 0.1) {
                    // 10%几率说话
                    showSpeech(getRandomItem(techFacts));
                } else if (randomAction < 0.15) {
                    // 5%几率睡觉
                    interactions.sleep.action();
                    showSpeech(getRandomItem(interactions.sleep.responses));
                } else if (randomAction < 0.2) {
                    // 5%几率思考
                    interactions.think.action();
                    showSpeech(getRandomItem(interactions.think.responses));
                }
            }
        }, 15000); // 每15秒检查一次
    }

    // 初始化
    function init() {
        // 设置初始位置
        robotContainer.style.position = 'fixed';
        robotContainer.style.left = `${robotState.position.x}px`;
        robotContainer.style.top = `${robotState.position.y}px`;
        robotContainer.style.bottom = 'auto';
        robotContainer.style.right = 'auto';

        // 初始化事件
        initEvents();

        // 开始动画循环
        updateRobotPosition();
    }

    // 启动
    init();
});